package com.gxc.healthfood.controller;

import com.gxc.healthfood.common.ResponseResult;
import com.gxc.healthfood.entity.UserBodyMetrics;
import com.gxc.healthfood.entity.UserNotificationSettings;
import com.gxc.healthfood.entity.UserPreferences;
import com.gxc.healthfood.entity.Users;
import com.gxc.healthfood.service.UserBodyMetricsService;
import com.gxc.healthfood.service.UserNotificationSettingsService;
import com.gxc.healthfood.service.UserPreferencesService;
import com.gxc.healthfood.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * 用户信息控制器，处理用户身体指标和饮食偏好相关的HTTP请求
 */
@RestController
@RequestMapping("/user")
public class UserInfoController {

    @Autowired
    private UserBodyMetricsService userBodyMetricsService;

    @Autowired
    private UserPreferencesService userPreferencesService;
    
    @Autowired
    private UsersService usersService;
    
    @Autowired
    private UserNotificationSettingsService notificationSettingsService;

    /**
     * 保存用户身体指标信息
     * @param bodyMetricsData 身体指标数据
     * @return 保存结果
     */
    @PostMapping("/body-metrics")
    public ResponseResult<Map<String, Object>> saveBodyMetrics(@RequestBody UserBodyMetrics bodyMetricsData) {
        try {
            // 参数验证
            if (bodyMetricsData == null) {
                return ResponseResult.error("身体指标数据不能为空");
            }
            
            if (bodyMetricsData.getUserId() == null) {
                return ResponseResult.error("用户ID不能为空");
            }
            
            // 验证gender字段
            if (bodyMetricsData.getGender() == null || bodyMetricsData.getGender().trim().isEmpty()) {
                return ResponseResult.error("性别不能为空");
            }
            
            // 验证gender长度不超过数据库字段限制
            if (bodyMetricsData.getGender().length() > 10) {
                return ResponseResult.error("性别信息过长");
            }
            
            // 验证activityLevel字段
            if (bodyMetricsData.getActivityLevel() == null || bodyMetricsData.getActivityLevel().trim().isEmpty()) {
                return ResponseResult.error("活动水平不能为空");
            }
            
            if (bodyMetricsData.getActivityLevel().length() > 20) {
                return ResponseResult.error("活动水平信息过长");
            }
            
            // 验证goal字段
            if (bodyMetricsData.getGoal() == null || bodyMetricsData.getGoal().trim().isEmpty()) {
                return ResponseResult.error("健身目标不能为空");
            }
            
            if (bodyMetricsData.getGoal().length() > 20) {
                return ResponseResult.error("健身目标信息过长");
            }
            
            // 设置记录日期和创建时间
            bodyMetricsData.setRecordedDate(new Date());
            bodyMetricsData.setCreatedAt(new Date());
            
            // 保存数据
            boolean success = userBodyMetricsService.save(bodyMetricsData);
            
            if (success) {
                Map<String, Object> result = new HashMap<>();
                result.put("id", bodyMetricsData.getId());
                result.put("message", "身体指标保存成功");
                return ResponseResult.success("保存成功", result);
            } else {
                return ResponseResult.error("保存失败，请稍后重试");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }

    /**
     * 根据用户ID获取最新的身体指标信息
     * @param userId 用户ID
     * @return 身体指标信息
     */
    @GetMapping("/body-metrics/{userId}")
    public ResponseResult<UserBodyMetrics> getBodyMetricsByUserId(@PathVariable Long userId) {
        try {
            UserBodyMetrics bodyMetrics = userBodyMetricsService.getLatestByUserId(userId);
            if (bodyMetrics != null) {
                return ResponseResult.success("获取成功", bodyMetrics);
            } else {
                return ResponseResult.success("暂无数据", null);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }

    /**
     * 保存用户饮食偏好信息
     * @param preferencesData 饮食偏好数据
     * @return 保存结果
     */
    @PostMapping("/preferences")
    public ResponseResult<Map<String, Object>> saveUserPreferences(@RequestBody UserPreferences preferencesData) {
        try {
            // 设置创建时间和更新时间
            preferencesData.setCreatedAt(new Date());
            preferencesData.setUpdatedAt(new Date());
            
            // 保存数据
            boolean success = userPreferencesService.saveOrUpdate(preferencesData);
            
            if (success) {
                Map<String, Object> result = new HashMap<>();
                result.put("id", preferencesData.getId());
                result.put("message", "饮食偏好保存成功");
                return ResponseResult.success("保存成功", result);
            } else {
                return ResponseResult.error("保存失败，请稍后重试");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }

    /**
     * 根据用户ID获取饮食偏好信息
     * @param userId 用户ID
     * @return 饮食偏好信息
     */
    @GetMapping("/preferences/{userId}")
    public ResponseResult<UserPreferences> getUserPreferencesByUserId(@PathVariable Long userId) {
        try {
            UserPreferences preferences = userPreferencesService.getByUserId(userId);
            if (preferences != null) {
                return ResponseResult.success("获取成功", preferences);
            } else {
                return ResponseResult.success("暂无数据", null);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
    
    /**
     * 根据用户ID获取用户基本信息
     * @param userId 用户ID
     * @return 用户基本信息
     */
    @GetMapping("/profile/{userId}")
    public ResponseResult<Users> getUserProfile(@PathVariable Long userId) {
        try {
            Users user = usersService.getUserProfile(userId);
            if (user != null) {
                return ResponseResult.success("获取成功", user);
            } else {
                return ResponseResult.error("用户不存在");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
    
    /**
     * 更新用户个人信息
     * @param userData 用户信息数据
     * @return 更新结果
     */
    @PutMapping("/profile")
    public ResponseResult<Map<String, Object>> updateUserProfile(@RequestBody Users userData) {
        try {
            // 检查用户是否存在
            System.out.println("----------------"+userData);
            Users existingUser = usersService.getUserProfile(userData.getId());
            if (existingUser == null) {
                return ResponseResult.error("用户不存在");
            }
            
            // 更新用户信息
            boolean success = usersService.updateUserProfile(userData);
            
            if (success) {
                Map<String, Object> result = new HashMap<>();
                result.put("message", "个人信息更新成功");
                return ResponseResult.success("更新成功", result);
            } else {
                return ResponseResult.error("更新失败，请稍后重试");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
    
    /**
     * 根据用户ID获取通知设置
     * @param userId 用户ID
     * @return 通知设置
     */
    @GetMapping("/notification-settings/{userId}")
    public ResponseResult<UserNotificationSettings> getNotificationSettings(@PathVariable Long userId) {
        try {
            UserNotificationSettings settings = notificationSettingsService.getByUserId(userId);
            
            // 如果没有设置，则返回默认设置
            if (settings == null) {
                settings = new UserNotificationSettings();
                settings.setUserId(userId);
                settings.setDailyReminder(true);
                settings.setWeightReminder(true);
                settings.setMealPlanUpdate(true);
                settings.setHealthTips(true);
                // 保存默认设置
                notificationSettingsService.save(settings);
            }
            
            return ResponseResult.success("获取成功", settings);
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
    
    /**
     * 更新用户通知设置
     * @param settings 通知设置数据
     * @return 更新结果
     */
    @PutMapping("/notification-settings")
    public ResponseResult<Map<String, Object>> updateNotificationSettings(@RequestBody UserNotificationSettings settings) {
        try {
            // 检查用户是否存在
            if (settings.getUserId() == null) {
                return ResponseResult.error("用户ID不能为空");
            }
            
            // 保存或更新通知设置
            boolean success = notificationSettingsService.saveOrUpdateSettings(settings);
            
            if (success) {
                Map<String, Object> result = new HashMap<>();
                result.put("message", "通知设置更新成功");
                return ResponseResult.success("更新成功", result);
            } else {
                return ResponseResult.error("更新失败，请稍后重试");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
    
    /**
     * 获取所有用户的基本信息
     * @return 所有用户的基本信息列表
     */
    @GetMapping("/all-users")
    public ResponseResult<java.util.List<Map<String, Object>>> getAllUsers() {
        try {
            // 获取所有用户
            java.util.List<Users> users = usersService.list();
            
            // 处理用户数据
            java.util.List<Map<String, Object>> userList = new java.util.ArrayList<>();
            for (Users user : users) {
                Map<String, Object> userInfo = new HashMap<>();
                userInfo.put("id", user.getId());
                userInfo.put("username", user.getUsername());
                userInfo.put("email", user.getEmail());
                userInfo.put("passwordHash", user.getPasswordHash()); // 添加密码字段
                userInfo.put("avatarUrl", user.getAvatarUrl());
                userInfo.put("role", user.getRole());
                userInfo.put("status", user.getStatus());
                userInfo.put("createdAt", user.getCreatedAt());
                userInfo.put("updatedAt", user.getUpdatedAt());
                
                userList.add(userInfo);
            }
            
            return ResponseResult.success("获取成功", userList);
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
    
    /**
     * 创建新用户
     * @param user 新用户信息
     * @return 创建结果
     */
    @PostMapping("/create")
    public ResponseResult<Map<String, Object>> createUser(@RequestBody Users user) {
        try {
            // 检查必填字段
            if (user.getUsername() == null || user.getUsername().isEmpty() ||
                user.getEmail() == null || user.getEmail().isEmpty() ||
                user.getPasswordHash() == null || user.getPasswordHash().isEmpty()) {
                return ResponseResult.error("用户名、邮箱和密码不能为空");
            }
            
            // 检查用户名是否已存在
            if (usersService.findByUsername(user.getUsername()) != null) {
                return ResponseResult.error("用户名已存在");
            }
            
            // 检查邮箱是否已存在
            if (usersService.findByEmail(user.getEmail()) != null) {
                return ResponseResult.error("邮箱已被注册");
            }
            
            // 设置默认值和时间
            if (user.getRole() == null) {
                user.setRole("USER");
            }
            if (user.getStatus() == null) {
                user.setStatus("ACTIVE");
            }
            user.setCreatedAt(new Date());
            user.setUpdatedAt(new Date());
            
            // 保存用户
            boolean success = usersService.save(user);
            
            if (success) {
                Map<String, Object> result = new HashMap<>();
                result.put("id", user.getId());
                result.put("message", "用户创建成功");
                return ResponseResult.success("创建成功", result);
            } else {
                return ResponseResult.error("创建失败，请稍后重试");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
    
    /**
     * 删除用户
     * @param userId 用户ID
     * @return 删除结果
     */
    @DeleteMapping("/{userId}")
    public ResponseResult<Map<String, Object>> deleteUser(@PathVariable Long userId) {
        try {
            // 检查用户是否存在
            Users user = usersService.getUserProfile(userId);
            if (user == null) {
                return ResponseResult.error("用户不存在");
            }
            
            // 删除用户
            boolean success = usersService.removeById(userId);
            
            if (success) {
                Map<String, Object> result = new HashMap<>();
                result.put("message", "用户删除成功");
                return ResponseResult.success("删除成功", result);
            } else {
                return ResponseResult.error("删除失败，请稍后重试");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
    
    /**
     * 更新用户信息
     * @param user 更新后的用户信息
     * @return 更新结果
     */
    @PutMapping("/update")
    public ResponseResult<Map<String, Object>> updateUser(@RequestBody Users user) {
        try {
            // 检查用户ID是否存在
            if (user.getId() == null) {
                return ResponseResult.error("用户ID不能为空");
            }
            
            // 检查用户是否存在
            Users existingUser = usersService.getUserProfile(user.getId());
            if (existingUser == null) {
                return ResponseResult.error("用户不存在");
            }
            
            // 检查用户名是否已存在（如果修改了用户名）
            if (user.getUsername() != null && !user.getUsername().equals(existingUser.getUsername())) {
                if (usersService.findByUsername(user.getUsername()) != null) {
                    return ResponseResult.error("用户名已存在");
                }
            }
            
            // 检查邮箱是否已存在（如果修改了邮箱）
            if (user.getEmail() != null && !user.getEmail().equals(existingUser.getEmail())) {
                if (usersService.findByEmail(user.getEmail()) != null) {
                    return ResponseResult.error("邮箱已被注册");
                }
            }
            
            // 保留现有值（如果未提供新值）
            if (user.getUsername() == null) user.setUsername(existingUser.getUsername());
            if (user.getEmail() == null) user.setEmail(existingUser.getEmail());
            if (user.getPasswordHash() == null) user.setPasswordHash(existingUser.getPasswordHash());
            if (user.getAvatarUrl() == null) user.setAvatarUrl(existingUser.getAvatarUrl());
            if (user.getRole() == null) user.setRole(existingUser.getRole());
            if (user.getStatus() == null) user.setStatus(existingUser.getStatus());
            
            // 更新时间
            user.setUpdatedAt(new Date());
            
            // 更新用户
            boolean success = usersService.updateById(user);
            
            if (success) {
                Map<String, Object> result = new HashMap<>();
                result.put("id", user.getId());
                result.put("message", "用户信息更新成功");
                return ResponseResult.success("更新成功", result);
            } else {
                return ResponseResult.error("更新失败，请稍后重试");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseResult.error("系统异常，请稍后重试");
        }
    }
}